package gsw.tool.rxjava.operator;

import gsw.tool.rxjava.Observer;

/**
 * Map操作符：将传递的参数转换为另一个对象返回，如果将其转换为与之不同的对象，对应的返回的Flowable对象参数也会变为转换后的对象
 */
public class OperatorMap<T, R> implements Operator<R, T> {
    //转换器
    Function<? super T, ? extends R> function;

    public OperatorMap(Function<? super T, ? extends R> function) {
        this.function = function;
    }

    /**
     * 将Observer转为使用Map操作符包装的Observer
     *
     * @param observer 原始Observer
     * @return 使用Map操作符包装的Observer
     */
    @Override
    public Observer<? super T> apply(Observer<? super R> observer) {
        return new MapSubscrible<>(observer, function);
    }

    /**
     * 使用Map操作符包装的Observer
     *
     * @param <T> 原始Action中的数据
     * @param <R> 转换后的数据
     */
    private class MapSubscrible<T, R> extends Observer<T> {
        //原始Action
        private Observer<? super R> actual;
        private Function<? super T, ? extends R> transform;

        public MapSubscrible(Observer<? super R> actual, Function<? super T, ? extends R> transform) {
            this.actual = actual;
            this.transform = transform;
        }

        @Override
        public void onNext(T t) {
            //转换原始Action中的数据
            R r = transform.apply(t);
            //使用原始Action处理转换后的数据
            actual.onNext(r);
        }

        @Override
        public void onError(Throwable e) {
            actual.onError(e);
        }

        @Override
        public void onComplete() {
            actual.onComplete();
        }
    }


}
